package com.meinv.auto;

import org.apache.commons.io.IOUtils;
import org.apache.http.Consts;
import org.apache.http.Header;
import org.apache.http.HttpEntity;  
import org.apache.http.HttpResponse;  
import org.apache.http.HttpStatus;  
import org.apache.http.NameValuePair;  
import org.apache.http.client.HttpClient;  
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.entity.GzipDecompressingEntity;
import org.apache.http.client.entity.UrlEncodedFormEntity;  
import org.apache.http.client.methods.CloseableHttpResponse;  
import org.apache.http.client.methods.HttpGet;  
import org.apache.http.client.methods.HttpPost;  
import org.apache.http.conn.ssl.SSLConnectionSocketFactory;  
import org.apache.http.conn.ssl.SSLContextBuilder;  
import org.apache.http.conn.ssl.TrustStrategy;  
import org.apache.http.conn.ssl.X509HostnameVerifier;
import org.apache.http.entity.ContentType;
import org.apache.http.entity.StringEntity;
import org.apache.http.entity.mime.HttpMultipartMode;
import org.apache.http.entity.mime.MultipartEntityBuilder;
import org.apache.http.entity.mime.content.FileBody;
import org.apache.http.entity.mime.content.StringBody;
import org.apache.http.impl.client.CloseableHttpClient;  
import org.apache.http.impl.client.DefaultHttpClient;  
import org.apache.http.impl.client.HttpClients;  
import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;  
import org.apache.http.message.BasicNameValuePair;  
import org.apache.http.util.EntityUtils;
import org.springframework.util.Base64Utils;

import com.alibaba.fastjson.JSONObject;

import javax.net.ssl.SSLContext;  
import javax.net.ssl.SSLException;  
import javax.net.ssl.SSLSession;  
import javax.net.ssl.SSLSocket;

import java.io.BufferedReader;
import java.io.File;
import java.io.IOException;  
import java.io.InputStream;
import java.io.InputStreamReader;
import java.nio.charset.Charset;  
import java.security.GeneralSecurityException;  
import java.security.cert.CertificateException;  
import java.security.cert.X509Certificate;  
import java.util.ArrayList;  
import java.util.HashMap;  
import java.util.List;  
import java.util.Map;  
  
/** 
 * HTTP 请求工具类 
 * 
 * @author : liii 
 * @version : 1.0.0 
 * @date : 2015/7/21 
 * @see : TODO 
 */  
public class HttpUtil {  
    private static PoolingHttpClientConnectionManager connMgr;  
    private static RequestConfig requestConfig;  
    private static final int MAX_TIMEOUT = 7000;  
  
    static {  
        // 设置连接池  
        connMgr = new PoolingHttpClientConnectionManager();  
        // 设置连接池大小  
        connMgr.setMaxTotal(100);  
        connMgr.setDefaultMaxPerRoute(connMgr.getMaxTotal());  
  
        RequestConfig.Builder configBuilder = RequestConfig.custom();  
        // 设置连接超时  
        configBuilder.setConnectTimeout(MAX_TIMEOUT);  
        // 设置读取超时  
        configBuilder.setSocketTimeout(MAX_TIMEOUT);  
        // 设置从连接池获取连接实例的超时  
        configBuilder.setConnectionRequestTimeout(MAX_TIMEOUT);  
        // 在提交请求之前 测试连接是否可用  
        configBuilder.setStaleConnectionCheckEnabled(true);  
        requestConfig = configBuilder.build();  
    }  
  
    /** 
     * 发送 GET 请求（HTTP），不带输入数据 
     * @param url 
     * @return 
     */  
    public static String doGet(String url) {  
        return doGet(url, new HashMap<String, Object>());  
    }  
  
    /** 
     * 发送 GET 请求（HTTP），K-V形式 
     * @param url 
     * @param params 
     * @return 
     */  
    public static String doGet(String url, Map<String, Object> params) {  
        String apiUrl = url;  
        StringBuffer param = new StringBuffer();  
        int i = 0;  
        for (String key : params.keySet()) {  
            if (i == 0)  
                param.append("?");  
            else  
                param.append("&");  
            param.append(key).append("=").append(params.get(key));  
            i++;  
        }  
        apiUrl += param;  
        String result = null;  
        HttpClient httpclient = new DefaultHttpClient();  
        try {  
            HttpGet httpPost = new HttpGet(apiUrl);  
            HttpResponse response = httpclient.execute(httpPost);  
            int statusCode = response.getStatusLine().getStatusCode();  
  
            System.out.println("执行状态码 : " + statusCode);  
  
            HttpEntity entity = response.getEntity();  
            if (entity != null) {  
                InputStream instream = entity.getContent();  
                result = IOUtils.toString(instream, "UTF-8");  
            }  
        } catch (IOException e) {  
            e.printStackTrace();  
        }  
        return result;  
    }  
  
    /** 
     * 发送 POST 请求（HTTP），不带输入数据 
     * @param apiUrl 
     * @return 
     */  
    public static String doPost(String apiUrl) {  
        return doPost(apiUrl, new HashMap<String, Object>());  
    }  
  
    /** 
     * 发送 POST 请求（HTTP），K-V形式 
     * @param apiUrl API接口URL 
     * @param params 参数map 
     * @return 
     */  
    public static String doPost(String apiUrl, Map<String, Object> params) {  
        CloseableHttpClient httpClient = HttpClients.createDefault();  
        String httpStr = null;  
        HttpPost httpPost = new HttpPost(apiUrl);  
        CloseableHttpResponse response = null;  
  
        try {  
            httpPost.setConfig(requestConfig);  
            List<NameValuePair> pairList = new ArrayList<NameValuePair>(params.size());  
            for (Map.Entry<String, Object> entry : params.entrySet()) {  
                NameValuePair pair = new BasicNameValuePair(entry.getKey(), entry  
                        .getValue().toString());  
                pairList.add(pair);  
            }  
            httpPost.setEntity(new UrlEncodedFormEntity(pairList, Charset.forName("UTF-8")));  
            response = httpClient.execute(httpPost);  
            System.out.println(response.toString());  
            HttpEntity entity = response.getEntity();  
            httpStr = EntityUtils.toString(entity, "UTF-8");  
        } catch (IOException e) {  
            e.printStackTrace();  
        } finally {  
            if (response != null) {  
                try {  
                    EntityUtils.consume(response.getEntity());  
                } catch (IOException e) {  
                    e.printStackTrace();  
                }  
            }  
        }  
        return httpStr;  
    }  
    
    
    
    private static String getContent(HttpEntity entity){
    	String content = null;
		try {
			InputStream in = null;  
			Header header = entity.getContentEncoding();  
			if(header != null && header.getValue().equalsIgnoreCase("gzip")){  
			      
			    GzipDecompressingEntity gzipEntity = new GzipDecompressingEntity(entity);  
			    in = gzipEntity.getContent();  
			}else{  
			    in = entity.getContent();  
			}  

			content = getHTMLContent(in);
		} catch (UnsupportedOperationException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}  
        return content;
    }
    
    private static String getHTMLContent(InputStream in) {  
        StringBuffer sb = new StringBuffer();  
        BufferedReader br = new BufferedReader(new InputStreamReader(in));  
        try {  
            String line = null;  
            while((line=br.readLine())!=null){  
                sb.append(line);  
            }  
              
        } catch (IOException e) {  
            e.printStackTrace();  
        }finally{  
            try {  
                br.close();  
            } catch (IOException e) {  
                e.printStackTrace();  
            }  
        }  
          
        return sb.toString();  
    }  
  
    /** 
     * 发送 POST 请求（HTTP），JSON形式 
     * @param apiUrl 
     * @param json json对象 
     * @return 
     */  
    public static String doPost(String apiUrl, Object json) {  
        CloseableHttpClient httpClient = HttpClients.createDefault();  
        String httpStr = null;  
        HttpPost httpPost = new HttpPost(apiUrl);  
        CloseableHttpResponse response = null;  
  
        try {  
            httpPost.setConfig(requestConfig);  
            StringEntity stringEntity = new StringEntity(json.toString(),"UTF-8");//解决中文乱码问题  
            stringEntity.setContentEncoding("UTF-8");  
            stringEntity.setContentType("application/json");  
            httpPost.setEntity(stringEntity);  
            response = httpClient.execute(httpPost);  
            HttpEntity entity = response.getEntity();  
            System.out.println(response.getStatusLine().getStatusCode());  
            httpStr = EntityUtils.toString(entity, "UTF-8");  
        } catch (IOException e) {  
            e.printStackTrace();  
        } finally {  
            if (response != null) {  
                try {  
                    EntityUtils.consume(response.getEntity());  
                } catch (IOException e) {  
                    e.printStackTrace();  
                }  
            }  
        }  
        return httpStr;  
    }  
  
   
    
    /** 
     * 发送 SSL GET 请求（HTTPS）
     * @param apiUrl API接口URL 
     * @param json JSON对象 
     * @return 
     */  
    public static String getCookieByGetSsl(String url) {  
        CloseableHttpClient httpClient = HttpClients.custom().setSSLSocketFactory(createSSLConnSocketFactory()).setConnectionManager(connMgr).setDefaultRequestConfig(requestConfig).build();  
        HttpGet httpGet = new HttpGet(url);  
        CloseableHttpResponse response = null;
  
        try {  
        	httpGet.setConfig(requestConfig);  
            
            response = httpClient.execute(httpGet); 
           System.out.println("response:"+response.getStatusLine().getStatusCode());
            int statusCode = response.getStatusLine().getStatusCode();  
            if (statusCode != HttpStatus.SC_OK) {  
                return null;
            }  
            HttpEntity entity = response.getEntity();  
            if (entity == null) {  
                return null;  
            }  
            //System.out.println("content:"+getContent(entity));
            
            Header[] header = response.getHeaders("set-cookie");
            if(header.length>0){
            	return header[0].getValue();
            }
            
        } catch (Exception e) {  
            e.printStackTrace();  
        } finally {
        	 if (response != null) {  
                 try {  
                     EntityUtils.consume(response.getEntity());  
                 } catch (IOException e) {  
                     e.printStackTrace();  
                 }  
             }  
		} 
        
        return null;  
    }  
    
    
    
  
    /** 
     * 发送 SSL POST 请求（HTTPS），JSON形式 
     * @param apiUrl API接口URL 
     * @param json JSON对象 
     * @return 
     */  
    public static String doPostSSL(String apiUrl, String json,Map<String,Object> headerMap) {  
        CloseableHttpClient httpClient = HttpClients.custom().setSSLSocketFactory(createSSLConnSocketFactory()).setConnectionManager(connMgr).setDefaultRequestConfig(requestConfig).build();  
        HttpPost httpPost = new HttpPost(apiUrl);  
        CloseableHttpResponse response = null;  
        String content = null;  
  
        try {  
            httpPost.setConfig(requestConfig);  
            StringEntity stringEntity = new StringEntity(json.toString(),"UTF-8");//解决中文乱码问题  
//            stringEntity.setContentEncoding("UTF-8");  
            stringEntity.setContentType("application/json");  
            httpPost.setEntity(stringEntity);
            
            for(String key:headerMap.keySet()){
            	httpPost.setHeader(key, headerMap.get(key).toString());
            }
            
            response = httpClient.execute(httpPost); 
           System.out.println("response:"+response.getStatusLine().getStatusCode());
            int statusCode = response.getStatusLine().getStatusCode();  
            if (statusCode != HttpStatus.SC_OK) {  
                return null;  
            }  
            HttpEntity entity = response.getEntity();  
            if (entity == null) {  
                return null;  
            }
            
            content =  getContent(entity);

        } catch (Exception e) {  
            e.printStackTrace();  
        } finally {  
            if (response != null) {  
                try {  
                    EntityUtils.consume(response.getEntity());  
                } catch (IOException e) {  
                    e.printStackTrace();  
                }  
            }  
        }  
        return content;  
    }  
  
    /** 
     * 发送  POST 请求（HTTPS/HTTP），JSON形式 ,模拟上传文件
     * @param apiUrl API接口URL 
     * @param json JSON对象 
     * @return 
     */  
    public static String doPost(boolean isSSL,String apiUrl,InputStream in, String fileName, Map<String, Object> params, Map<String,Object> headerMap) {  
    	CloseableHttpClient httpClient = null;
    	if(isSSL) {
    		httpClient = HttpClients.custom().setSSLSocketFactory(createSSLConnSocketFactory()).setConnectionManager(connMgr).setDefaultRequestConfig(requestConfig).build();  
    	}else {
    		httpClient = HttpClients.createDefault();  
    	}
        HttpPost httpPost = new HttpPost(apiUrl);  
        CloseableHttpResponse response = null;  
        String content = null;  
  
        try {  
            httpPost.setConfig(requestConfig);  
            
            MultipartEntityBuilder builder = MultipartEntityBuilder.create();  
            builder.setMode(HttpMultipartMode.BROWSER_COMPATIBLE);  
            builder.addBinaryBody("file", in, /*ContentType.MULTIPART_FORM_DATA*/
            		ContentType.create("multipart/form-data"), fileName);  
            
            for (String key : params.keySet()) {
            	builder.addPart(key, new StringBody(params.get(key).toString(), ContentType.TEXT_PLAIN));
            }
//          builder.setCharset(Charset.forName("UTF-8"));
//          builder.setContentType(ContentType.APPLICATION_JSON);
            
            HttpEntity hentity = builder.build();  
            httpPost.setEntity(hentity);  
            
            for(String key:headerMap.keySet()){
            	httpPost.setHeader(key, headerMap.get(key).toString());
            }
            
            response = httpClient.execute(httpPost); 
           System.out.println("response:"+response.getStatusLine().getStatusCode());
            int statusCode = response.getStatusLine().getStatusCode();  
            if (statusCode != HttpStatus.SC_OK) {  
                return null;  
            }  
            HttpEntity entity = response.getEntity();  
            if (entity == null) {  
                return null;  
            }
            
            content =  getContent(entity);

        } catch (Exception e) {  
            e.printStackTrace();  
        } finally { 
    	   if (in!= null) {
	        	try {
					in.close();
				} catch (IOException e1) {
					e1.printStackTrace();
				}
    	   }
            if (response != null) {  
                try {  
                    EntityUtils.consume(response.getEntity());  
                } catch (IOException e) {  
                    e.printStackTrace();  
                }  
            }  
        }  
        return content;  
    }
    
    /** 
     * 创建SSL安全连接 
     * 
     * @return 
     */  
    private static SSLConnectionSocketFactory createSSLConnSocketFactory() {  
        SSLConnectionSocketFactory sslsf = null;  
        try {  
            SSLContext sslContext = new SSLContextBuilder().loadTrustMaterial(null, new TrustStrategy() {  
  
                public boolean isTrusted(X509Certificate[] chain, String authType) throws CertificateException {  
                    return true;  
                }  
            }).build();  
            sslsf = new SSLConnectionSocketFactory(sslContext, new X509HostnameVerifier() {  
  
//                @Override  
                public boolean verify(String arg0, SSLSession arg1) {  
                    return true;  
                }  
  
//                @Override  
                public void verify(String host, SSLSocket ssl) throws IOException {  
                }  
  
//                @Override  
                public void verify(String host, X509Certificate cert) throws SSLException {  
                }  
  
//                @Override  
                public void verify(String host, String[] cns, String[] subjectAlts) throws SSLException {  
                }  
            });  
        } catch (GeneralSecurityException e) {  
            e.printStackTrace();  
        }  
        return sslsf;  
    }  
  
  
    /** 
     * 测试方法 
     * @param args 
     */  
    public static void main(String[] args) throws Exception {  
    	String portal_url = "https://pangolin.bytedance.com/auth/login";
		String encryPass = "HI2h7E30z6jpE8GF5gE8HqJkG1bbPPRMyDqJekfVdgI/htjtabkrdY4F3M3S+OwX3yfR7+fvavLJUOrbvm6k+1tZRNPpR5tTrF5sU/nMeiFkqBB+C5WhBVQ1X61HJCpV4z7IOEwWAkjaDqJg2NecrSuljySgBpKJJn5ZFCBT+u0=";
		
//		String cookie = HttpUtil.getCookieByGetSsl(portal_url);
//		System.out.println(cookie);
		
		String cookie = "connect.sid=s%3Aw58QjMWVjnPU1TCUGEVkgD73azMECcz7.%2FhKATmv5S65c3IFyJ6%2BXIR1mmCDj6RHy44Z%2BpXCOySI; Path=/; HttpOnly";
		
		Map<String, Object> param = new HashMap<String,Object>();
		param.put("username", "kydsp");
		param.put("password", encryPass);
		param.put("captcha", "VZU5");
		JSONObject json = new JSONObject(param);
		
		Map<String, Object> header = new HashMap<String,Object>();
		header.put("cookie", cookie);
		
		String res = HttpUtil.doPostSSL("https://pangolin.bytedance.com/auth/do_login",json.toJSONString(),header);
		try {
			JSONObject _json = JSONObject.parseObject(res);
			System.out.println(_json.getString("message"));
		} catch (Exception e) {
			e.printStackTrace();
		}
		
    }  
}
